﻿using System.ComponentModel;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;

namespace Framework.Core
{
	public class CacheHelp
	{
		private static ICacheProvider _cacheProvider;
		private readonly CacheOptions _cacheOptions;

		public CacheHelp(ICacheProvider cacheProvider, IOptions<CacheOptions> cacheOptions)
		{
			_cacheProvider = cacheProvider;
			_cacheOptions = cacheOptions.Value;
		}

		/// <summary>
		/// 申请分布式锁 🔖
		/// </summary>
		/// <param name="key">要锁定的key</param>
		/// <param name="msTimeout">申请锁等待的时间，单位毫秒</param>
		/// <param name="msExpire">锁过期时间，超过该时间没有主动是放则自动是放，必须整数秒，单位毫秒</param>
		/// <param name="throwOnFailure">失败时是否抛出异常,如不抛出异常，可通过判断返回null得知申请锁失败</param>
		/// <returns></returns>
		public IDisposable? BeginCacheLock(string key, int msTimeout = 500, int msExpire = 10000, bool throwOnFailure = true)
		{
			try
			{
				return _cacheProvider.Cache.AcquireLock(key, msTimeout, msExpire, throwOnFailure);
			}
			catch
			{
				return null;
			}
		}

		/// <summary>
		/// 获取缓存键名集合 🔖
		/// </summary>
		/// <returns></returns>
		public List<string> GetKeyList()
		{
			return _cacheProvider.Cache == NewLife.Caching.Cache.Default
				? [.. _cacheProvider.Cache.Keys.Where(u => u.StartsWith(_cacheOptions.Prefix)).Select(u => u[_cacheOptions.Prefix.Length..]).OrderBy(u => u)]
				: [.. ((FullRedis)_cacheProvider.Cache).Search($"{_cacheOptions.Prefix}*", int.MaxValue).Select(u => u[_cacheOptions.Prefix.Length..]).OrderBy(u => u)];
		}

		/// <summary>
		/// 增加缓存
		/// </summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		[NonAction]
		public bool Set(string key, object value)
		{
			return !string.IsNullOrWhiteSpace(key) && _cacheProvider.Cache.Set($"{_cacheOptions.Prefix}{key}", value);
		}

		/// <summary>
		/// 增加缓存并设置过期时间
		/// </summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		/// <param name="expire"></param>
		/// <returns></returns>
		[NonAction]
		public bool Set(string key, object value, TimeSpan expire)
		{
			return !string.IsNullOrWhiteSpace(key) && _cacheProvider.Cache.Set($"{_cacheOptions.Prefix}{key}", value, expire);
		}

		public async Task<TR> AdGetAsync<TR>(String cacheName, Func<Task<TR>> del, TimeSpan? expiry = default) where TR : class
		{
			return await AdGetAsync<TR>(cacheName, del, [], expiry);
		}

		public async Task<TR> AdGetAsync<TR, T1>(String cacheName, Func<T1, Task<TR>> del, T1 t1, TimeSpan? expiry = default) where TR : class
		{
			return await AdGetAsync<TR>(cacheName, del, [t1], expiry);
		}

		public async Task<TR> AdGetAsync<TR, T1, T2>(String cacheName, Func<T1, T2, Task<TR>> del, T1 t1, T2 t2, TimeSpan? expiry = default) where TR : class
		{
			return await AdGetAsync<TR>(cacheName, del, [t1, t2], expiry);
		}

		public async Task<TR> AdGetAsync<TR, T1, T2, T3>(String cacheName, Func<T1, T2, T3, Task<TR>> del, T1 t1, T2 t2, T3 t3, TimeSpan? expiry = default) where TR : class
		{
			return await AdGetAsync<TR>(cacheName, del, [t1, t2, t3], expiry);
		}

		private async Task<T> AdGetAsync<T>(string cacheName, Delegate del, Object[] obs, TimeSpan? expiry) where T : class
		{
			var key = Key(cacheName, obs);
			// 使用分布式锁
			using (_cacheProvider.Cache.AcquireLock($@"lock:AdGetAsync:{cacheName}", 1000))
			{
				var value = Get<T>(key);
				value ??= await ((dynamic)del).DynamicInvokeAsync(obs);
				Set(key, value);
				return value;
			}
		}

		public T Get<T>(String cacheName, object t1)
		{
			return Get<T>(cacheName, [t1]);
		}

		public T Get<T>(String cacheName, object t1, object t2)
		{
			return Get<T>(cacheName, [t1, t2]);
		}

		public T Get<T>(String cacheName, object t1, object t2, object t3)
		{
			return Get<T>(cacheName, [t1, t2, t3]);
		}

		private T Get<T>(String cacheName, Object[] obs)
		{
			var key = cacheName + ":" + obs.Aggregate(string.Empty, (current, o) => current + $"<{o}>");
			return Get<T>(key);
		}

		private static string Key(string cacheName, object[] obs)
		{
			if (obs.OfType<TimeSpan>().Any()) throw new Exception("缓存参数类型不能能是:TimeSpan类型");
			StringBuilder sb = new(cacheName + ":");
			foreach (var a in obs) sb.Append($"<{KeySingle(a)}>");
			return sb.ToString();
		}

		private static string KeySingle(object t)
		{
			return t.GetType().IsClass && !t.GetType().IsPrimitive ? JsonConvert.SerializeObject(t) : t.ToString();
		}

		/// <summary>
		/// 获取缓存的剩余生存时间
		/// </summary>
		/// <param name="key"></param>
		/// <returns></returns>
		[NonAction]
		public TimeSpan GetExpire(string key)
		{
			return _cacheProvider.Cache.GetExpire(key);
		}

		/// <summary>
		/// 获取缓存
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		[NonAction]
		public T Get<T>(string key)
		{
			return _cacheProvider.Cache.Get<T>($"{_cacheOptions.Prefix}{key}");
		}

		/// <summary>
		/// 删除缓存 🔖
		/// </summary>
		/// <param name="key"></param>
		/// <returns></returns>
		public int Remove(string key)
		{
			return _cacheProvider.Cache.Remove($"{_cacheOptions.Prefix}{key}");
		}

		/// <summary>
		/// 清空所有缓存 🔖
		/// </summary>
		/// <returns></returns>
		public void Clear()
		{
			_cacheProvider.Cache.Clear();

			NewLife.Caching.Cache.Default.Clear();
		}

		/// <summary>
		/// 检查缓存是否存在
		/// </summary>
		/// <param name="key">键</param>
		/// <returns></returns>
		[NonAction]
		public bool ExistKey(string key)
		{
			return _cacheProvider.Cache.ContainsKey($"{_cacheOptions.Prefix}{key}");
		}

		/// <summary>
		/// 根据键名前缀删除缓存 🔖
		/// </summary>
		/// <param name="prefixKey">键名前缀</param>
		/// <returns></returns>
		public int RemoveByPrefixKey(string prefixKey)
		{
			var delKeys = _cacheProvider.Cache == NewLife.Caching.Cache.Default
				? _cacheProvider.Cache.Keys.Where(u => u.StartsWith($"{_cacheOptions.Prefix}{prefixKey}")).ToArray()
				: ((FullRedis)_cacheProvider.Cache).Search($"{_cacheOptions.Prefix}{prefixKey}*", int.MaxValue).ToArray();
			return _cacheProvider.Cache.Remove(delKeys);
		}

		/// <summary>
		/// 根据键名前缀获取键名集合 🔖
		/// </summary>
		/// <param name="prefixKey">键名前缀</param>
		/// <returns></returns>
		[DisplayName("根据键名前缀获取键名集合")]
		public List<string> GetKeysByPrefixKey(string prefixKey)
		{
			return _cacheProvider.Cache == NewLife.Caching.Cache.Default
				? _cacheProvider.Cache.Keys.Where(u => u.StartsWith($"{_cacheOptions.Prefix}{prefixKey}")).Select(u => u[_cacheOptions.Prefix.Length..]).ToList()
				: ((FullRedis)_cacheProvider.Cache).Search($"{_cacheOptions.Prefix}{prefixKey}*", int.MaxValue).Select(u => u[_cacheOptions.Prefix.Length..]).ToList();
		}

		/// <summary>
		/// 获取缓存值 🔖
		/// </summary>
		/// <param name="key"></param>
		/// <returns></returns>
		[DisplayName("获取缓存值")]
		public object GetValue(string key)
		{
			// 若Key经过URL编码则进行解码
			if (Regex.IsMatch(key, @"%[0-9a-fA-F]{2}"))
				key = HttpUtility.UrlDecode(key);

			return _cacheProvider.Cache == NewLife.Caching.Cache.Default
				? _cacheProvider.Cache.Get<object>($"{_cacheOptions.Prefix}{key}")
				: _cacheProvider.Cache.Get<string>($"{_cacheOptions.Prefix}{key}");
		}

		/// <summary>
		/// 获取或添加缓存（在数据不存在时执行委托请求数据）
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="callback"></param>
		/// <param name="expire">过期时间，单位秒</param>
		/// <returns></returns>
		[NonAction]
		public T GetOrAdd<T>(string key, Func<string, T> callback, int expire = -1)
		{
			if (string.IsNullOrWhiteSpace(key)) return default;
			return _cacheProvider.Cache.GetOrAdd($"{_cacheOptions.Prefix}{key}", callback, expire);
		}

		/// <summary>
		/// Hash匹配
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		[NonAction]
		public IDictionary<String, T> GetHashMap<T>(string key)
		{
			return _cacheProvider.Cache.GetDictionary<T>(key);
		}

		/// <summary>
		/// 批量添加HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="dic"></param>
		/// <returns></returns>
		[NonAction]
		public bool HashSet<T>(string key, Dictionary<string, T> dic)
		{
			var hash = GetHashMap<T>(key);
			foreach (var v in dic)
			{
				hash.Add(v);
			}
			return true;
		}

		/// <summary>
		/// 添加一条HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="hashKey"></param>
		/// <param name="value"></param>
		[NonAction]
		public void HashAdd<T>(string key, string hashKey, T value)
		{
			var hash = GetHashMap<T>(key);
			hash.Add(hashKey, value);
		}

		/// <summary>
		/// 添加或更新一条HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="hashKey"></param>
		/// <param name="value"></param>
		[NonAction]
		public void HashAddOrUpdate<T>(string key, string hashKey, T value)
		{
			var hash = GetHashMap<T>(key);
			if (hash.ContainsKey(hashKey))
				hash[hashKey] = value;
			else
				hash.Add(hashKey, value);
		}

		/// <summary>
		/// 获取多条HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="fields"></param>
		/// <returns></returns>
		[NonAction]
		public List<T> HashGet<T>(string key, params string[] fields)
		{
			var hash = GetHashMap<T>(key);
			return hash.Where(t => fields.Any(c => t.Key == c)).Select(t => t.Value).ToList();
		}

		/// <summary>
		/// 获取一条HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="field"></param>
		/// <returns></returns>
		[NonAction]
		public T HashGetOne<T>(string key, string field)
		{
			var hash = GetHashMap<T>(key);
			return hash.TryGetValue(field, out T value) ? value : default;
		}

		/// <summary>
		/// 根据KEY获取所有HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		[NonAction]
		public IDictionary<string, T> HashGetAll<T>(string key)
		{
			var hash = GetHashMap<T>(key);
			return hash;
		}

		/// <summary>
		/// 删除HASH
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="fields"></param>
		/// <returns></returns>
		[NonAction]
		public int HashDel<T>(string key, params string[] fields)
		{
			var hash = GetHashMap<T>(key);
			fields.ToList().ForEach(t => hash.Remove(t));
			return fields.Length;
		}

		///// <summary>
		///// 搜索HASH
		///// </summary>
		///// <typeparam name="T"></typeparam>
		///// <param name="key"></param>
		///// <param name="searchModel"></param>
		///// <returns></returns>
		//[NonAction]
		//public List<KeyValuePair<string, T>> HashSearch<T>(string key, SearchModel searchModel)
		//{
		//    var hash = GetHashMap<T>(key);
		//    return hash.Search(searchModel).ToList();
		//}

		///// <summary>
		///// 搜索HASH
		///// </summary>
		///// <typeparam name="T"></typeparam>
		///// <param name="key"></param>
		///// <param name="pattern"></param>
		///// <param name="count"></param>
		///// <returns></returns>
		//[NonAction]
		//public List<KeyValuePair<string, T>> HashSearch<T>(string key, string pattern, int count)
		//{
		//    var hash = GetHashMap<T>(key);
		//    return hash.Search(pattern, count).ToList();
		//}
	}
}
